#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

// 定义全局信号量，控制线程执行顺序
sem_t sem_BA, sem_CA, sem_AD, sem_AE, sem_DF, sem_EF;

// 线程函数声明
void* thread_A(void* arg);
void* thread_B(void* arg);
void* thread_C(void* arg);
void* thread_D(void* arg);
void* thread_E(void* arg);
void* thread_F(void* arg);

int main() {
    pthread_t tid_B, tid_A, tid_C, tid_D, tid_E, tid_F;

    // 初始化信号量：初始值为 0，表示线程需等待触发
    sem_init(&sem_BA, 0, 0);  // A 等待 B的信号
    sem_init(&sem_CA, 0, 0);  // A 等待 C 的信号
    sem_init(&sem_AD, 0, 0);  // D 等待 A 的信号
    sem_init(&sem_AE, 0, 0);  // E 等待 A 的信号
    sem_init(&sem_DF, 0, 0);  // F 等待 D 的信号
    sem_init(&sem_EF, 0, 0);  // F 等待 E 的信号

    // 创建所有线程
    pthread_create(&tid_A, NULL, thread_A, NULL);
    pthread_create(&tid_B, NULL, thread_B, NULL);
    pthread_create(&tid_C, NULL, thread_C, NULL);
    pthread_create(&tid_D, NULL, thread_D, NULL);
    pthread_create(&tid_E, NULL, thread_E, NULL);
    pthread_create(&tid_F, NULL, thread_F, NULL);

    // 等待所有线程结束
    pthread_join(tid_A, NULL);
    pthread_join(tid_B, NULL);
    pthread_join(tid_C, NULL);
    pthread_join(tid_D, NULL);
    pthread_join(tid_E, NULL);
    pthread_join(tid_F, NULL);

    // 销毁信号量，释放资源
    sem_destroy(&sem_BA);
    sem_destroy(&sem_CA);
    sem_destroy(&sem_AD);
    sem_destroy(&sem_AE);
    sem_destroy(&sem_DF);
    sem_destroy(&sem_EF);

    return 0;
}

// 线程 B：执行完后给 A 发送信号
void* thread_B(void* arg) {
    printf("Thread B 执行完毕\n");
    sem_post(&sem_BA);  // 发信号给 A
    pthread_exit(NULL);
}

// 线程 C：执行完后给 A 发送信号
void* thread_C(void* arg) {
    printf("Thread C 执行完毕\n");
    sem_post(&sem_CA);  // 发信号给 A
    pthread_exit(NULL);
}

// 线程 A：必须等待 B 和 C 都执行完后才能执行
void* thread_A(void* arg) {
    sem_wait(&sem_BA);  // 等待 B 的信号
    sem_wait(&sem_CA);  // 等待 C 的信号
    printf("Thread A 执行完毕\n");
    sem_post(&sem_AD);  // 发信号给 D
    sem_post(&sem_AE);  // 发信号给 E
    pthread_exit(NULL);
}

// 线程 D：等待 A 执行完后执行
void* thread_D(void* arg) {
    sem_wait(&sem_AD);  // 等待 A 的信号
    printf("Thread D 执行完毕\n");
    sem_post(&sem_DF);  // 发信号给 F
    pthread_exit(NULL);
}

// 线程 E：等待 A 执行完后执行，然后允许 F 执行
void* thread_E(void* arg) {
    sem_wait(&sem_AE);  // 等待 A 的信号
    printf("Thread E 执行完毕\n");
    sem_post(&sem_EF);  // 发信号给 F
    pthread_exit(NULL);
}

// 线程 F：等待 D 和 E 执行完后执行
void* thread_F(void* arg) {
    sem_wait(&sem_DF);  // 等待 D 的信号
    sem_wait(&sem_EF);  // 等待 E 的信号
    printf("Thread F 执行完毕\n");
    pthread_exit(NULL);
}  